#ifndef THREAD_HPP
#define THREAD_HPP

#include <iostream>
#include <unistd.h>
#include <pthread.h>
#include <string.h>
#include <sys/types.h>
#include <functional>

namespace ThreadModule
{
    int number = 1;                                       // 保证线程name的唯一性
    using func_t = std::function<void(std::string name)>; // func_t代替void()类型的函数
    enum class TSTATUS                                    // 线程状态
    {
        NEW,
        RUNNING,
        STOP
    };
    class Thread
    {
    private:
        // 这里传参必须用static
        // 非静态成员函数 隐式携带一个 this 指针，指向调用它的对象实例。
        // 线程函数（如 pthread_create 的第三个参数）要求是一个普通的 C 风格函数指针（或兼容的函数对象）
        // 它不接受隐式的 this 参数。
        // 如果 Rutine 是非静态的，编译器会报错，因为函数签名不匹配（多了一个隐式的 this 参数）。
        // 静态成员函数 不依赖对象实例，没有隐式的 this 指针。
        // 它的函数签名与普通 C 风格函数兼容，可以直接作为线程函数使用。

        static void *Rutine(void *args)
        {
            Thread *t = static_cast<Thread *>(args); // 获取线程
            t->_status = TSTATUS::RUNNING;           // 更改线程状态
            t->_func(t->Name());                     // 执行传给线程的函数
            return nullptr;
        }
        void ChJoin()
        {
            _joinable = false;
        }

    public:
        Thread(func_t func)
            : _joinable(true),
              _func(func),
              _status(TSTATUS::NEW)
        {
            _name = "thread-" + std::to_string(number++);
            _pid = getpid();
        }
        bool Start()
        {
            if (_status != TSTATUS::RUNNING) // 防止线程被重复启动
            {
                int n = ::pthread_create(&_tid, nullptr, Rutine, (void *)this);
                if (n != 0)
                {
                    return false;
                }
                return true;
            }
            return false;
        }
        bool Stop()
        {
            if (_status == TSTATUS::RUNNING) // 只有运行状态才能终止
            {
                int n = pthread_cancel(_tid); // 线程自己退
                if (n == 0)
                {
                    _status = TSTATUS::STOP;
                    return true;
                }
                return false;
            }
            return false;
        }
        bool Join()
        {
            // 分离状态下无法进行等待
            if (IsJoinable())
            {
                int n = pthread_join(_tid, nullptr);
                if (n == 0)
                {
                    _status = TSTATUS::STOP;
                    return true;
                }
                return false;
            }
            return false;
        }
        void Detach()
        {
            ChJoin();
            pthread_detach(_tid);
        }
        bool IsJoinable() // 检查线程是否可以被连接
        {
            return _joinable;
        }
        // 测试接口
        std::string Name()
        {
            return _name;
        }
        ~Thread()
        {
        }

    private:
        std::string _name;
        pid_t _pid;      // 所属进程id
        pthread_t _tid;  // 线程id
        bool _joinable;  // 是否分离
        TSTATUS _status; // 线程状态
        func_t _func;    // 所要线程实现的函数
    };
}
#endif